package com.li.onjava8.concurrent.cf;

import com.li.onjava8.concurrent.cf.task.Workable;

import java.util.concurrent.CompletableFuture;
import static com.li.onjava8.concurrent.cf.task.CompletableUtilities.*;
/**
 * 现在，我们可以创建多个竞争的CompletableFuture，并使用CompletableFuture库
 * @author li
 * @date 2023/10/31 14:18
 */
public class DualCompletableOperations {
    static CompletableFuture<Workable> cfA, cfB;
    static void init() {
        cfA = Workable.make("A", 0.15);
        cfB = Workable.make("B", 0.10);
    }

    static void join() {
        cfA.join();
        cfB.join();
        System.out.println("***********");
    }

    public static void main(String[] args) {
        init();
        //runAfterEither: 返回一个新的 CompletionStage，当此阶段或另一个给定阶段正常完成时，使用此阶段的默认异步执行工具执行给定操作。
        voidr(cfA.runAfterEitherAsync(cfB, () -> System.out.println("runAfterEither")));
        join();
        init();
        //runAfterBoth: 返回一个新的 CompletionStage，当此阶段和另一个给定阶段都正常完成时，使用此阶段的默认异步执行工具执行给定操作。
        voidr(cfA.runAfterBothAsync(cfB, () -> System.out.println("runAfterBoth")));
        join();
        init();
        //applyToEither: 返回一个新的 CompletionStage，当此阶段或另一个给定阶段正常完成时，将使用此阶段的默认异步执行工具执行该阶段，并将相应的结果作为所提供函数的参数。
        showr(cfA.applyToEitherAsync(cfB, w -> {
            System.out.println("applyToEither:" + w);
            return w;
        }));
        join();
        init();
        //acceptEither: 返回一个新的 CompletionStage，当此阶段或另一个给定阶段正常完成时，将使用此阶段的默认异步执行工具执行该阶段，并将相应的结果作为所提供操作的参数。
        voidr(cfA.acceptEitherAsync(cfB, w -> {
            System.out.println("acceptEither:" + w);
        }));
        join();
        init();
        //thenAcceptBoth: 返回一个新的CompletionStage，当这个和另一个给定的阶段都正常完成时，使用该阶段的默认异步执行工具执行该阶段，并将两个结果作为所提供操作的参数。
        voidr(cfA.thenAcceptBothAsync(cfB, (w1, w2) -> {
            System.out.println("thenAcceptBoth:" + w1 + "," + w2);
        }));
        join();
        init();
        //thenCombine: 返回一个新的 CompletionStage，当此阶段和另一个给定阶段都正常完成时，将使用此阶段的默认异步执行工具执行该阶段，并将两个结果作为所提供函数的参数。
        showr(cfA.thenCombineAsync(cfB, (w1, w2) -> {
            System.out.println("thenCombine:" + w1 + ", " + w2);
            return w1;
        }));
        join();
        init();
        CompletableFuture<Workable> cfC = Workable.make("C", 0.08);
        CompletableFuture<Workable> cfD = Workable.make("D", 0.09);
        //anyOf: 返回一个新的 CompletableFuture，当任何给定的 CompletableFuture 完成时，该 CompletableFuture 就会完成，并具有相同的结果。
        CompletableFuture.anyOf(cfA, cfB, cfC, cfD).thenRunAsync(() -> System.out.println("anyOf"));
        join();
        init();
        cfC = Workable.make("C", 0.08);
        cfD = Workable.make("D", 0.09);
        //allOf: 返回一个新的 CompletableFuture，当所有给定的 CompletableFuture 完成时，该 CompletableFuture 也完成。 如果任何给定的 CompletableFuture 异常完成，则返回的 CompletableFuture 也会异常完成
        CompletableFuture.allOf(cfA, cfB, cfC, cfD)
                .thenRunAsync(() -> System.out.println("allOf"));
        join();
    }


}
